FastAPI Bog'liqliklarni Kiritish: Ilg'or DI Konteyner Arxitekturasi

FastAPI, o'zining intuitiv dizayni va kuchli xususiyatlari bilan Python'da zamonaviy veb API'lar yaratish uchun sevimli vositaga aylandi. Uning asosiy kuchli tomonlaridan biri bu bog'liqliklarni kiritish (DI) bilan uzluksiz integratsiyalashuvidir, bu esa dasturchilarga bo'sh bog'langan, testlanadigan va qo'llab-quvvatlanadigan ilovalar yaratish imkonini beradi. FastAPI'ning o'rnatilgan DI tizimi oddiy holatlar uchun a'lo darajada bo'lsa-da, murakkabroq loyihalar ko'pincha yanada tizimli va ilg'or DI konteyner arxitekturasidan foyda ko'radi. Ushbu maqola shunday arxitekturani yaratishning turli strategiyalarini o'rganib chiqadi, mustahkam va o'lchamlanuvchi ilovalarni loyihalash uchun amaliy misollar va tushunchalar taqdim etadi.

Bog'liqliklarni Kiritish (DI) va Boshqaruvni Inversiyalash (IoC) ni Tushunish

Ilg'or DI konteyner arxitekturalariga sho'ng'ishdan oldin, asosiy tushunchalarga aniqlik kiritib olaylik:

• Bog'liqliklarni Kiritish (DI): Bu dizayn namunasi bo'lib, unda bog'liqliklar komponentga ichki ravishda yaratilish o'rniga tashqi manbalardan taqdim etiladi. Bu bo'sh bog'lanishni rag'batlantiradi, komponentlarni testlash va qayta ishlatishni osonlashtiradi.
• Boshqaruvni Inversiyalash (IoC): Bu kengroq tamoyil bo'lib, unda obyektlarni yaratish va boshqarish nazorati teskari aylantiriladi – freymvork yoki konteynerga topshiriladi. DI IoC'ning maxsus bir turidir.

FastAPI o'zining bog'liqliklar tizimi orqali DI'ni tabiiy ravishda qo'llab-quvvatlaydi. Siz bog'liqliklarni chaqiriladigan obyektlar (funksiyalar, sinflar va h.k.) sifatida belgilaysiz va FastAPI ularni avtomatik ravishda aniqlaydi va sizning endpoint funksiyalaringizga yoki boshqa bog'liqliklarga kiritadi.

Misol (Asosiy FastAPI DI):

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Bog'liqlik
def get_db():
    db = {"items": []}  # Ma'lumotlar bazasi ulanishini simulyatsiya qilish
    try:
        yield db
    finally:
        # Ma'lumotlar bazasi ulanishini yopish (agar kerak bo'lsa)
        pass


# Bog'liqlik kiritilgan endpoint
@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

Ushbu misolda get_db ma'lumotlar bazasi ulanishini ta'minlaydigan bog'liqlikdir. FastAPI avtomatik ravishda get_db'ni chaqiradi va natijani (db lug'atini) read_items endpoint funksiyasiga kiritadi.

Nima Uchun Ilg'or DI Konteyner Kerak?

FastAPI'ning o'rnatilgan DI tizimi oddiy loyihalar uchun yaxshi ishlaydi, ammo ilovalar murakkablashgan sari, yanada rivojlangan DI konteyner bir nechta afzalliklarni taqdim etadi:

• Markazlashtirilgan Bog'liqliklarni Boshqarish: Maxsus konteyner barcha bog'liqliklar uchun yagona haqiqat manbasini ta'minlaydi, bu esa ilovaning bog'liqliklarini boshqarish va tushunishni osonlashtiradi.
• Konfiguratsiya va Hayot Davrini Boshqarish: Konteyner bog'liqliklarning konfiguratsiyasi va hayot davrini boshqarishi mumkin, masalan, singletonlar yaratish, ulanishlarni boshqarish va resurslarni yo'q qilish.
• Testlanuvchanlik: Ilg'or konteyner bog'liqliklarni soxta (mock) obyektlar yoki test dublyorlari bilan osongina almashtirish imkonini berib, testlashni soddalashtiradi.
• Bog'liqlikni uzish: Komponentlar o'rtasida katta darajada bog'liqlikni uzishga yordam beradi, bog'liqliklarni kamaytiradi va kodning qo'llab-quvvatlanuvchanligini yaxshilaydi.
• Kengaytiriluvchanlik: Kengaytiriladigan konteyner kerak bo'lganda maxsus xususiyatlar va integratsiyalarni qo'shish imkonini beradi.

Ilg'or DI Konteyner Yaratish Strategiyalari

FastAPI'da ilg'or DI konteyner yaratishning bir nechta yondashuvlari mavjud. Quyida ba'zi umumiy strategiyalar keltirilgan:

1. Maxsus DI Kutubxonasidan Foydalanish (masalan, `injector`, `dependency_injector`)

Python uchun `injector` va `dependency_injector` kabi bir nechta kuchli DI kutubxonalari mavjud. Bu kutubxonalar bog'liqliklarni boshqarish uchun keng qamrovli xususiyatlar to'plamini taqdim etadi, jumladan:

• Bog'lash: Bog'liqliklar qanday aniqlanishi va kiritilishini belgilash.
• Skoplar: Bog'liqliklarning hayot davrini nazorat qilish (masalan, singleton, vaqtinchalik).
• Konfiguratsiya: Bog'liqliklar uchun konfiguratsiya sozlamalarini boshqarish.
• AOP (Aspektga Yo'naltirilgan Dasturlash): Kesishuvchi vazifalar uchun metod chaqiruvlarini to'xtatib turish.

`dependency_injector` bilan misol

dependency_injector DI konteynerlarini yaratish uchun mashhur tanlovdir. Keling, uning ishlatilishini misol bilan ko'rib chiqamiz:

            
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Bog'liqliklarni aniqlash
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
        # Ma'lumotlar bazasi ulanishini initsializatsiya qilish
        print(f"Ma'lumotlar bazasiga ulanish: {self.connection_string}")

    def get_items(self):
        # Ma'lumotlar bazasidan elementlarni olishni simulyatsiya qilish
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        # Barcha foydalanuvchilarni olish uchun ma'lumotlar bazasiga so'rovni simulyatsiya qilish
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Konteynerni aniqlash
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# FastAPI ilovasini yaratish
app = FastAPI()

# Konteynerni sozlash (muhit o'zgaruvchisidan)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # FastAPI endpoint'lariga bog'liqliklarni kiritishni yoqadi

# FastAPI uchun bog'liqlik
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Kiritilgan bog'liqlikdan foydalanadigan endpoint
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Konteynerni initsializatsiya qilish
    container.init_resources()

            

              
                Copy
              
            
          

Tushuntirish:

• Biz o'z bog'liqliklarimizni (Database, UserRepository, Settings) oddiy Python sinflari sifatida belgilaymiz.
• Biz containers.DeclarativeContainer'dan meros oluvchi Container sinfini yaratamiz. Bu sinf bog'liqliklarni va ularning provayderlarini (masalan, singletonlar uchun providers.Singleton, har safar yangi nusxa yaratish uchun providers.Factory) belgilaydi.
• container.wire([__name__]) qatori FastAPI endpoint'lariga bog'liqliklarni kiritish imkonini beradi.
• get_user_repository funksiyasi FastAPI bog'liqligi bo'lib, u UserRepository nusxasini konteynerdan olish uchun container.user_repository.provided'dan foydalanadi.
• read_users endpoint funksiyasi UserRepository bog'liqligini kiritadi.
• config sizga bog'liqlik konfiguratsiyalarini tashqariga chiqarish imkonini beradi. Keyin u muhit o'zgaruvchilari, konfiguratsiya fayllari va hokazolardan olinishi mumkin.
• startup_event konteynerda boshqariladigan resurslarni initsializatsiya qilish uchun ishlatiladi.

2. Maxsus DI Konteynerni Yaratish

DI jarayoni ustidan ko'proq nazorat qilish uchun siz maxsus DI konteynerni yaratishingiz mumkin. Bu yondashuv ko'proq harakat talab qiladi, lekin konteynerni o'zingizning maxsus ehtiyojlaringizga moslashtirish imkonini beradi.

Oddiy Maxsus DI Konteyner Misoli:

            
from typing import Callable, Dict, Type, Any
from fastapi import FastAPI, Depends

class Container:
    def __init__(self):
        self.dependencies: Dict[Type[Any], Callable[..., Any]] = {}
        self.instances: Dict[Type[Any], Any] = {}

    def register(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.dependencies[dependency_type] = provider

    def resolve(self, dependency_type: Type[Any]) -> Any:
        if dependency_type in self.instances:
            return self.instances[dependency_type]

        if dependency_type not in self.dependencies:
            raise Exception(f"Bog'liqlik {dependency_type} ro'yxatdan o'tmagan.")

        provider = self.dependencies[dependency_type]
        instance = provider()
        return instance

    def singleton(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.register(dependency_type, provider)
        self.instances[dependency_type] = provider()


# Misol Bog'liqliklar
class PaymentGateway:
    def process_payment(self, amount: float) -> bool:
        print(f"${amount} miqdoridagi to'lovni qayta ishlash")
        return True # Muvaffaqiyatli to'lovni simulyatsiya qilish


class NotificationService:
    def send_notification(self, message: str):
        print(f"Bildirishnoma yuborish: {message}")


# Foydalanish Misoli
container = Container()
container.singleton(PaymentGateway, PaymentGateway)
container.singleton(NotificationService, NotificationService)

app = FastAPI()

# FastAPI Bog'liqligi
def get_payment_gateway(payment_gateway: PaymentGateway = Depends(lambda: container.resolve(PaymentGateway))):
    return payment_gateway


def get_notification_service(notification_service: NotificationService = Depends(lambda: container.resolve(NotificationService))):
    return notification_service


@app.post("/purchase/")
async def purchase_item(payment_gateway: PaymentGateway = Depends(get_payment_gateway), notification_service: NotificationService = Depends(get_notification_service)):
    if payment_gateway.process_payment(100.0):
        notification_service.send_notification("Xarid muvaffaqiyatli amalga oshirildi!")
        return {"message": "Xarid muvaffaqiyatli amalga oshirildi"}
    else:
        return {"message": "Xarid amalga oshmadi"}

            

              
                Copy
              
            
          

Tushuntirish:

• Container sinfi bog'liqliklar va ularning provayderlari lug'atini boshqaradi.
• register metodi bog'liqlikni uning provayderi bilan ro'yxatdan o'tkazadi.
• resolve metodi bog'liqlikni uning provayderini chaqirish orqali hal qiladi.
• singleton metodi bog'liqlikni ro'yxatdan o'tkazadi va uning yagona nusxasini yaratadi.
• FastAPI bog'liqliklari konteynerdan bog'liqliklarni hal qilish uchun lambda funksiyasidan foydalanib yaratiladi.

3. FastAPI'ning `Depends`'ini Fabrika Funksiyasi Bilan Ishlatish

To'liq DI konteyner o'rniga, siz bog'liqliklarni boshqarishning ma'lum darajasiga erishish uchun FastAPI'ning `Depends`'ini fabrika funksiyalari bilan birgalikda ishlatishingiz mumkin. Bu yondashuv maxsus konteynerni yaratishdan ko'ra soddaroq, ammo baribir endpoint funksiyalari ichida bog'liqliklarni to'g'ridan-to'g'ri yaratishdan ko'ra ba'zi afzalliklarni taqdim etadi.

            
from fastapi import FastAPI, Depends
from typing import Callable

# Bog'liqliklarni Aniqlash
class EmailService:
    def __init__(self, smtp_server: str):
        self.smtp_server = smtp_server

    def send_email(self, recipient: str, subject: str, body: str):
        print(f"{recipient} ga {self.smtp_server} orqali xat yuborish: {subject} - {body}")


# EmailService uchun fabrika funksiyasi
def create_email_service(smtp_server: str) -> EmailService:
    return EmailService(smtp_server=smtp_server)


# FastAPI
app = FastAPI()

# FastAPI Bog'liqligi, fabrika funksiyasi va Depends'dan foydalanish
def get_email_service(email_service: EmailService = Depends(lambda: create_email_service(smtp_server="smtp.example.com"))):
    return email_service


@app.post("/send-email/")
async def send_email(recipient: str, subject: str, body: str, email_service: EmailService = Depends(get_email_service)):
    email_service.send_email(recipient=recipient, subject=subject, body=body)
    return {"message": "Xat yuborildi!"}

            

              
                Copy
              
            
          

Tushuntirish:

• Biz EmailService bog'liqligining nusxalarini yaratadigan fabrika funksiyasini (create_email_service) belgilaymiz.
• get_email_service bog'liqligi fabrika funksiyasini chaqirish va EmailService nusxasini taqdim etish uchun Depends va lambda'dan foydalanadi.
• send_email endpoint funksiyasi EmailService bog'liqligini kiritadi.

Ilg'or Mulohazalar

1. Skoplar va Hayot Davrlari

DI konteynerlari ko'pincha bog'liqliklarning hayot davrini boshqarish uchun xususiyatlarni taqdim etadi. Umumiy skoplar quyidagilarni o'z ichiga oladi:

• Singleton: Bog'liqlikning yagona nusxasi yaratiladi va ilovaning butun hayoti davomida qayta ishlatiladi. Bu holatsiz yoki global skopga ega bog'liqliklar uchun mos keladi.
• Vaqtinchalik (Transient): Har safar so'ralganda bog'liqlikning yangi nusxasi yaratiladi. Bu holatli yoki bir-biridan ajratilishi kerak bo'lgan bog'liqliklar uchun mos keladi.
• So'rov (Request): Har bir kiruvchi so'rov uchun bog'liqlikning yagona nusxasi yaratiladi. Bu bitta so'rov kontekstida holatni saqlashi kerak bo'lgan bog'liqliklar uchun mos keladi.

dependency_injector kutubxonasi skoplar uchun o'rnatilgan qo'llab-quvvatlashni ta'minlaydi. Maxsus konteynerlar uchun siz skopni boshqarish mantig'ini o'zingiz yozishingiz kerak bo'ladi.

2. Konfiguratsiya

Bog'liqliklar ko'pincha ma'lumotlar bazasi ulanish satrlari, API kalitlari va funksiyalarni yoqish/o'chirish bayroqlari kabi konfiguratsiya sozlamalarini talab qiladi. DI konteynerlari konfiguratsiya qiymatlariga kirish va ularni kiritishning markazlashtirilgan usulini taqdim etish orqali ushbu sozlamalarni boshqarishga yordam beradi.

dependency_injector misolida, config provayderi muhit o'zgaruvchilaridan konfiguratsiyani olish imkonini beradi. Maxsus konteynerlar uchun siz konfiguratsiyani fayllardan yoki muhit o'zgaruvchilaridan yuklab, ularni konteynerda saqlashingiz mumkin.

3. Testlash

DI'ning asosiy afzalliklaridan biri bu testlanuvchanlikning yaxshilanishidir. DI konteyneri yordamida siz testlash paytida haqiqiy bog'liqliklarni osongina soxta (mock) obyektlar yoki test dublyorlari bilan almashtirishingiz mumkin.

Misol (`dependency_injector` bilan testlash):

            
import pytest
from unittest.mock import MagicMock
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient

# Bog'liqliklarni aniqlash (avvalgidek)
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    def get_items(self):
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Konteynerni aniqlash (avvalgidek)
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# FastAPI ilovasini yaratish (avvalgidek)
app = FastAPI()

# Konteynerni sozlash (muhit o'zgaruvchisidan)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # FastAPI endpoint'lariga bog'liqliklarni kiritishni yoqadi

# FastAPI uchun bog'liqlik
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Kiritilgan bog'liqlikdan foydalanadigan endpoint (avvalgidek)
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Konteynerni initsializatsiya qilish
    container.init_resources()

# Test
@pytest.fixture
def test_client():
    # Ma'lumotlar bazasi bog'liqligini soxta (mock) bilan almashtirish
    database_mock = MagicMock(spec=Database)
    database_mock.get_items.return_value = [{"id": 3, "name": "Test Item"}]

    user_repository_mock = MagicMock(spec = UserRepository)
    user_repository_mock.get_all_users.return_value = [{"id": "test_user", "name": "Test User"}]

    # Konteynerni soxta bog'liqliklar bilan almashtirish
    container.user_repository.override(providers.Factory(lambda: user_repository_mock))

    with TestClient(app) as client:
        yield client
    container.user_repository.reset()


def test_read_users(test_client: TestClient):
    response = test_client.get("/users/")
    assert response.status_code == 200
    assert response.json() ==  [{"id": "test_user", "name": "Test User"}]

            

              
                Copy
              
            
          

Tushuntirish:

• Biz MagicMock yordamida Database bog'liqligi uchun soxta obyekt yaratamiz.
• Konteynerdagi database provayderini container.database.override() yordamida soxta obyekt bilan almashtiramiz.
• test_read_items test funksiyasi endi soxta ma'lumotlar bazasi bog'liqligidan foydalanadi.
• Test bajarilgandan so'ng, u konteynerning almashtirilgan bog'liqligini tiklaydi.

4. Asinxron Bog'liqliklar

FastAPI asinxron dasturlash (async/await) ustiga qurilgan. Asinxron bog'liqliklar (masalan, asinxron ma'lumotlar bazasi ulanishlari) bilan ishlaganda, sizning DI konteyneringiz va bog'liqlik provayderlaringiz asinxron operatsiyalarni qo'llab-quvvatlashiga ishonch hosil qiling.

Misol (`dependency_injector` bilan Asinxron Bog'liqlik):

            
import asyncio
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Asinxron bog'liqlikni aniqlash
class AsyncDatabase:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    async def connect(self):
        print(f"Ma'lumotlar bazasiga ulanish: {self.connection_string}")
        await asyncio.sleep(0.1) # Ulanish vaqtini simulyatsiya qilish

    async def fetch_data(self):
        await asyncio.sleep(0.1) # Ma'lumotlar bazasi so'rovini simulyatsiya qilish
        return [{"id": 1, "name": "Async Item 1"}]

# Konteynerni aniqlash
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    database = providers.Singleton(AsyncDatabase, connection_string=config.database_url)

# FastAPI ilovasini yaratish
app = FastAPI()

# Konteynerni sozlash
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__])

# FastAPI uchun bog'liqlik
async def get_async_database(database: AsyncDatabase = Depends(container.database.provided)) -> AsyncDatabase:
    await database.connect()
    return database


# Kiritilgan bog'liqlikdan foydalanadigan endpoint
@app.get("/async-items/")
async def read_async_items(database: AsyncDatabase = Depends(get_async_database)):
    data = await database.fetch_data()
    return data


@app.on_event("startup")
async def startup_event():
    # Konteynerni initsializatsiya qilish
    container.init_resources()

            

              
                Copy
              
            
          

Tushuntirish:

• AsyncDatabase sinfi async va await yordamida asinxron metodlarni belgilaydi.
• get_async_database bog'liqligi ham asinxron funksiya sifatida belgilangan.
• read_async_items endpoint funksiyasi async sifatida belgilangan va database.fetch_data() natijasini kutadi.

To'g'ri Yondashuvni Tanlash

Ilg'or DI konteyner yaratish uchun eng yaxshi yondashuv ilovangizning murakkabligiga va sizning maxsus talablaringizga bog'liq:

• Kichik va o'rta hajmdagi loyihalar uchun: FastAPI'ning o'rnatilgan DI tizimi yoki Depends bilan fabrika funksiyasi yondashuvi yetarli bo'lishi mumkin.
• Katta, murakkabroq loyihalar uchun: dependency_injector kabi maxsus DI kutubxonasi bog'liqliklarni boshqarish uchun keng qamrovli xususiyatlar to'plamini taqdim etadi.
• DI jarayoni ustidan nozik nazorat talab qiladigan loyihalar uchun: Maxsus DI konteynerni yaratish eng yaxshi variant bo'lishi mumkin.

Xulosa

Bog'liqliklarni kiritish - bu o'lchamlanuvchi, qo'llab-quvvatlanadigan va testlanadigan ilovalar yaratish uchun kuchli usuldir. FastAPI'ning o'rnatilgan DI tizimi oddiy holatlar uchun a'lo darajada bo'lsa-da, ilg'or DI konteyner arxitekturasi murakkabroq loyihalar uchun sezilarli afzalliklarni taqdim etishi mumkin. To'g'ri yondashuvni tanlab va DI kutubxonalarining xususiyatlaridan foydalanib yoki maxsus konteyner yaratib, siz FastAPI ilovalaringizning umumiy sifati va qo'llab-quvvatlanuvchanligini yaxshilaydigan mustahkam va moslashuvchan bog'liqliklarni boshqarish tizimini yaratishingiz mumkin.

Global Mulohazalar

Global ilovalar uchun DI konteynerlarini loyihalashda quyidagilarni hisobga olish muhim:

• Mahalliylashtirish: Mahalliylashtirish bilan bog'liq bog'liqliklar (masalan, til sozlamalari, sana formatlari) turli mintaqalarda bir xillikni ta'minlash uchun DI konteyneri tomonidan boshqarilishi kerak.
• Vaqt Mintaqalari: Vaqt mintaqasi ma'lumotlarini qattiq kodlashdan saqlanish uchun vaqt mintaqasi konversiyalarini boshqaradigan bog'liqliklar kiritilishi kerak.
• Valyuta: Turli valyutalarni qo'llab-quvvatlash uchun valyuta konversiyasi va formatlash uchun bog'liqliklar konteyner tomonidan boshqarilishi kerak.
• Mintaqaviy Sozlamalar: Raqam formatlari va manzil formatlari kabi boshqa mintaqaviy sozlamalar ham DI konteyneri tomonidan boshqarilishi kerak.
• Ko'p ijarachilik (Multi-tenancy): Ko'p ijarachili ilovalar uchun DI konteyneri turli ijarachilar uchun turli bog'liqliklarni taqdim eta olishi kerak. Bunga skoplar yoki maxsus bog'liqliklarni hal qilish mantig'idan foydalanish orqali erishish mumkin.
• Muvofiqlik va Xavfsizlik: Sizning bog'liqliklarni boshqarish strategiyangiz turli mintaqalardagi tegishli ma'lumotlar maxfiyligi qoidalariga (masalan, GDPR, CCPA) va xavfsizlikning eng yaxshi amaliyotlariga mos kelishini ta'minlang. Maxfiy hisob ma'lumotlari va konfiguratsiyalarni konteyner ichida xavfsiz tarzda boshqaring.

Ushbu global omillarni hisobga olgan holda, siz global muhitda ishlaydigan ilovalarni yaratish uchun juda mos keladigan DI konteynerlarini yaratishingiz mumkin.